package top.imyzt.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * String的工具类
 * @author imyzt
 * @date 2017-12-19
 *
 */
public class StringUtils {

	/**
	 * 1.字符串与基本数据类型、包装类之间的转换<br/>
	 * <li>字符串--》基本数据类型、包装类,调用相应包装类的parseXXX(String str)方法</li>
	 * <li>基本数据类型、包装类--》字符串,调用字符串的重载valueOf()方法</li>
	 */
	public static void example(){
		String str = "123";
		int i = 123;
			
		//1.字符串与基本数据类型、包装类之间的转换
		Long.parseLong(str);
		String.valueOf(i);
		//2.字符串与字节数组之间的转换
		str.getBytes();
		new String(str.getBytes());
		//3.字符串与字符数组之间的转换
		str.toCharArray();
		new String(str.toCharArray());
	}
	
	
	/**
	 * 字符串倒序输出
	 * @param str
	 * @param trim
	 * @return
	 */
	public static String reverseString(String str, boolean trim){

		str = trim ? str.trim() : str;
		
		if ("".equals(str) || str.length() == 1) {
			return str;
		}
		
		StringBuffer sb = new StringBuffer();
		//字符串最后一位索引
		int len = str.length() -1;
		for (int i = len; i >= 0; i--) {
			sb.append(str.charAt(i));
		}
		return sb.toString();
	}
	
	/**
	 * 判断字符串是否为空<br/>
	 * trim = true时去空格比较
	 * @param str 字符串
	 * @param trim 是否去空格
	 * @return
	 */
	public static boolean isNullOrEmpty(String str, boolean trim){
		
		str = trim && str != null ? str.trim() : str;
		
		boolean bool = "".equals(str) || str == null ? true : false;
		
		return bool;
	}
	
	/**
	 * 比较两个字符串是否相同
	 * @param a 字符串a
	 * @param b 字符串b
	 * @param trim 是否去空格
	 * @param ignoreCase 是否区分大小写
	 * @return
	 */
	public static boolean equals(String a, String b, boolean trim, boolean ignoreCase){
		
		boolean bool  = a == null && b == null ? true : false;
		
		if (a != null && b != null) {
			
			if (trim) {
				a = a.trim();
				b = b.trim();
			}
			
			if (ignoreCase) {
				bool = a.toLowerCase().equals(b.toLowerCase());
			}else{
				bool = a.equals(b);
			}
		}
		return bool;
	}
	
	/**
	 * 在字符串1的指定位置插入字符串2
	 * @param source 字符串1
	 * @param newString 字符串2
	 * @param startwith 插入位置
	 * @return
	 */
	public static String fillString(String source, String newString, int startwith){
		
		//判断是否为空
		if (isNullOrEmpty(source, false) || isNullOrEmpty(newString, false)) {
			throw new IllegalArgumentException("字符串不能为空或null");
		}
		
		//判断位置是否大于startwith
		if (startwith > source.length()) {
			throw new IllegalArgumentException("指定长度" + startwith + "超过source.length()");
		}
		
		StringBuffer sb = new StringBuffer(source);
		sb.insert(startwith, newString);
		
		return sb.toString();
	}
	
	/**
	 * 去除JSON字符串两边的中括号
	 * @param json JSON字符串
	 * @return
	 */
	public static String removeJSONBrackets(String json){
		if (!isNullOrEmpty(json, true)) {
			if (json.startsWith("[") && json.endsWith("]")) {
				return json.substring(1, json.length() - 1);
			}
		}
		return json;
	}
	
	/**
	 * 将字符串转化成List
	 * @param str 字符串
	 * @param regex 截取规则
	 * @return
	 */
	public static List<String> stringToColl(String str, String regex){
		List<String> list = new ArrayList<String>();
		if (isNullOrEmpty(str, true) || str.length() == 0 || isNullOrEmpty(regex, false)) {
			return null;
		}
		
		String[] arrString = str.split(regex);
		for (String s : arrString) {
			list.add(s);
		}
		return null;
	}
	
	/**
	 * 将的List转化成String
	 * @param list list集合
	 * @param regex 分割规则
	 * @return
	 */
	public static String collToString(List<String> list, String regex){
		
		if (list.size() == 0 || list == null || isNullOrEmpty(regex, false)) {
			return "";
		}
		StringBuffer sb = new StringBuffer();
		for (String s : list) {
			sb.append(s + regex);
		}
		return sb.toString().substring(0,sb.lastIndexOf(regex));
	}
	
	/**
	 * 指定字符串位置倒序
	 * @param str 字符串
	 * @param start 倒序开始位置
	 * @param end 倒序结束位置
	 * <br/><br/>
	 * <code>
	 * reverseString("abcde", 2, 4)<br/>
	 * abedc
	 * </code>
	 * @return
	 */
	public static String reverseString(String str, int start, int end){
		
		if (isNullOrEmpty(str, true) || start < 0 || end < 0 || end > str.length()) {
			return str;
		}
		
		StringBuffer sb = new StringBuffer(str.substring(0, start));
		for (int i = end; i >= start; i--) {
			sb.append(str.charAt(i));
		}
		sb.append(str.substring(end + 1));
		return sb.toString();
	}
	
	/**
	 * 去字符串首尾空格,排除空指针异常
	 * 如果字符串为Null,返回空串
	 * @param str 字符串
	 * @return
	 */
	public static String trim(String str){
		if (isNullOrEmpty(str, false)) {
			return "";
		}
		int start = 0;
		int end = str.length() - 1;
		while (start < end && str.charAt(start) == ' ') {
			start ++;
		}
		while (start < end && str.charAt(end) == ' ') {
			end --;
		}
		return str.substring(start, end + 1);
	}
	
	/**
	 * 比较字符串b在字符串a中的出现次数
	 * @param a 字符串a
	 * @param b 字符串b
	 * @return
	 */
	public static int getTime(String a, String b){
		
		if (isNullOrEmpty(a, false) || isNullOrEmpty(b, false)) {
			return 0;
		}
		
		int count = 0;
		int len = 0;
		while ((len = a.indexOf(b)) != -1){
			count ++;
			//将字符串a向后移len+b.length()个位置.
			a = a.substring(len + b.length());
		}
		return count;
	}


	/**
	 * 字符串排序
	 * @param str 待排序的字符串
	 * @param reverse 排序依据
	 * 
	 * <br/><br/>
	 * <code>
	 * reverse = true 字符串正序
	 * <br/>
	 * reverse = false 字符串反序
	 * </code>
	 * @return
	 */
	public static String sort(String str, boolean reverse){
		
		if (isNullOrEmpty(str, true)) {
			return "";
		}
		
		//将字符串顺序
		char[] c = str.toCharArray();
		Arrays.sort(c);
		
		if (!reverse) {
			//将正序后的字符串反序
			StringBuffer sb = new StringBuffer(new String(c));
			sb.reverse();
			return sb.toString();
		}
		return new String(c);
	}
	
	public static void main(String[] args) {
		System.out.println(sort("adeqbqe",false));
	}
}
